package corrector

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"net/http"

	"github.com/yourusername/tinput/internal/config"
	"github.com/yourusername/tinput/internal/core/storage"
)

// CorrectionResult 表示语法纠正的结果
type CorrectionResult struct {
	Input     string
	Corrected string
	Diff      string
	ErrorType string
}

// DeepSeekRequest 表示发送给DeepSeek API的请求结构
type DeepSeekRequest struct {
	Model    string    `json:"model"`
	Messages []Message `json:"messages"`
}

// Message 表示请求中的消息
type Message struct {
	Role    string `json:"role"`
	Content string `json:"content"`
}

// APIResponse 表示API返回的JSON结构
type APIResponse struct {
	Corrected string `json:"corrected"`
	Suggest   string `json:"suggest"`
	Grammer   string `json:"grammer"`
}

// Data 结构体表示响应中的 data 字段内容
type Data struct {
	OriginalSentence string `json:"originalSentence"`
	Username         string `json:"username"`
	Result           string `json:"result"`
	RequestId        string `json:"requestId"`
}

// DefaultResponse 结构体表示默认引擎的完整响应格式
type DefaultResponse struct {
	Code    int    `json:"code"`
	Message string `json:"message"`
	Data    Data   `json:"data"`
}

// DefaultEngineRequest 表示发送给默认引擎的请求结构
type DefaultEngineRequest struct {
	Sentence string `json:"sentence"`
	Username string `json:"username"`
}

// DeepSeekResponse 表示DeepSeek API的响应结构
type DeepSeekResponse struct {
	Choices []struct {
		Message Message `json:"message"`
	} `json:"choices"`
}

// callDefaultEngine 调用默认引擎进行语法纠正
func callDefaultEngine(input string, username string) (DefaultResponse, error) {
	url := "https://dev-5genhwgo604cfadc-1251845214.ap-shanghai.app.tcloudbase.com/fixlang" // 默认引擎地址

	// 创建请求体
	reqBody := DefaultEngineRequest{
		Sentence: input,
		Username: username,
	}

	// 转换为JSON
	jsonData, err := json.Marshal(reqBody)
	if err != nil {
		return DefaultResponse{}, fmt.Errorf("JSON序列化失败: %v", err)
	}

	// 创建HTTP请求
	req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
	if err != nil {
		return DefaultResponse{}, fmt.Errorf("创建请求失败: %v", err)
	}

	// 设置请求头
	req.Header.Set("Content-Type", "application/json")

	// 发送请求
	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		return DefaultResponse{}, fmt.Errorf("发送请求失败: %v", err)
	}
	defer resp.Body.Close()

	// 检查响应状态
	if resp.StatusCode != http.StatusOK {
		return DefaultResponse{}, fmt.Errorf("请求失败，状态码: %d", resp.StatusCode)
	}

	// 读取完整响应体
	respBody, err := io.ReadAll(resp.Body)
	if err != nil {
		return DefaultResponse{}, fmt.Errorf("读取响应体失败: %v", err)
	}

	// 打印完整HTTP响应字符串
	println("HTTP响应字符串: " + string(respBody))

	// 解析响应
	var apiResp DefaultResponse
	if err := json.Unmarshal(respBody, &apiResp); err != nil {
		return DefaultResponse{}, fmt.Errorf("解析响应失败: %v", err)
	}

	println("纠正结果: " + apiResp.Data.Result)
	return apiResp, nil
}

// callDeepSeekAPI 调用DeepSeek API进行语法纠正
func callDeepSeekAPI(input string, apiKey, modelType string) (APIResponse, error) {
	url := "https://api.deepseek.com/chat/completions"

	// 创建请求体
	reqBody := DeepSeekRequest{
		Model: modelType,
		Messages: []Message{
			{
				Role:    "system",
				Content: "你是一个英语专家，擅长语法纠正。请纠正用户输入中的英语语法错误，并提供改进建议,尽量把输入纠正成常用的口语，并给出一个类似意思的口语版本，建议时把句子用的语法时态都解释一下， 并指定里面涉及到的语法种类。请严格按照以下JSON格式返回，不要包含任何额外内容：{\"corrected\": \"纠正后的文本\", \"suggest\": \"你的建议\", \"grammer\": \"用户写错的语法的种类\"}",
			},
			{
				Role:    "user",
				Content: input,
			},
		},
	}

	// 转换为JSON
	jsonData, err := json.Marshal(reqBody)
	if err != nil {
		return APIResponse{}, fmt.Errorf("JSON序列化失败: %v", err)
	}

	// 创建HTTP请求
	req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
	if err != nil {
		return APIResponse{}, fmt.Errorf("创建请求失败: %v", err)
	}

	// 设置请求头
	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", apiKey))

	// 发送请求
	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		return APIResponse{}, fmt.Errorf("发送请求失败: %v", err)
	}
	defer resp.Body.Close()

	// 解析响应
	var response DeepSeekResponse
	if err := json.NewDecoder(resp.Body).Decode(&response); err != nil {
		return APIResponse{}, fmt.Errorf("解析响应失败: %v", err)
	}

	// 检查响应
	if len(response.Choices) == 0 {
		return APIResponse{}, fmt.Errorf("没有获取到纠正结果")
	}

	// 解析返回的JSON内容
	var apiResp APIResponse
	if err := json.Unmarshal([]byte(response.Choices[0].Message.Content), &apiResp); err != nil {
		return APIResponse{}, fmt.Errorf("解析API返回的JSON失败: %v", err)
	}

	return apiResp, nil
}

// Correct 纠正输入文本的语法
func Correct(input string) (string, string, string, string) {
	// 获取配置
	cfg := config.GetConfig()

	corrected := input
	errorType := ""
	suggestion := ""
	grammer := ""

	// 根据配置选择纠正引擎
	if cfg.CorrectionEngine == "deepseek" && cfg.DeepSeekKey != "" && cfg.ModelType != "" {
		// 调用DeepSeek API
		apiResponse, err := callDeepSeekAPI(input, cfg.DeepSeekKey, cfg.ModelType)
		if err != nil {
			corrected = input
			errorType = "API错误"
		} else {
			corrected = apiResponse.Corrected
			suggestion = apiResponse.Suggest
			grammer = apiResponse.Grammer

			if corrected != input {
				errorType = "语法错误"
			} else {
				errorType = "无"
			}
		}
	} else if cfg.CorrectionEngine == "default" {
		println("process:" + input + " user=" + cfg.Token)
		// 检查用户名是否配置
		if cfg.Token == "" {
			// 提示用户配置用户名
			corrected = "请先到配置页面配置用户名"
			errorType = "未配置用户名"
		} else {
			// 调用默认引擎
			apiResponse, err := callDefaultEngine(input, cfg.Token)
			if err != nil {
				corrected = "error:" + err.Error()
				errorType = "默认引擎错误: " + err.Error()
			} else {
				corrected = apiResponse.Data.Result

				if corrected != input {
					errorType = "语法错误"
				} else {
					errorType = "无"
				}
			}
		}
	} else {
		corrected = "please config first"
		errorType = "please config first"
	}

	// 保存纠正记录，直接传递input、corrected和suggestion，不使用diff字段
	storage.SaveHistory(input, corrected, suggestion, grammer)

	return corrected, suggestion, grammer, errorType
}
